Unix Development Environment¶
Unix 开发环境 ¶

user@machine:~$

sudo apt update

sudo apt upgrade -y

sudo apt install -y zip unzip build-essential

Install OPAM¶ 安装 OPAM ¶

Linux. Follow the instructions for your distribution.
Linux。请遵循您的发行版的说明。

Mac. If you’re using Homebrew, run this command:
苹果。如果您使用的是 Homebrew，请运行以下命令：

brew install opam

If you’re using MacPorts, run this command:
如果您使用的是 MacPorts，请运行以下命令：

sudo port install opam

Windows. Run this command from Ubuntu:
视窗。从 Ubuntu 运行此命令：

sudo apt install opam

Initialize OPAM¶ 初始化 OPAM ¶

Linux, Mac, and WSL2. Run:
Linux、Mac 和 WSL2。跑步：

opam init --bare -a -y

It is expected behavior to get a note about making sure .profile is well sourced in .bashrc. You don’t need to do anything about that.
预期行为会得到有关确保 .profile 在 .bashrc 中来源良好的注释。你不需要对此做任何事情。

WSL1. Hopefully you are running WSL2, not WSL1. But on WSL1, run:
WSL1。希望您运行的是 WSL2，而不是 WSL1。但在 WSL1 上运行：

opam init --bare -a -y --disable-sandboxing

It is necessary to disable sandboxing because of an issue involving OPAM and WSL1.
由于涉及 OPAM 和 WSL1 的问题，有必要禁用沙箱。

Create an OPAM Switch¶
创建 OPAM 开关 ¶

A switch 转变 is a named installation of OCaml with a particular compiler version and set of packages.
是 OCaml 的命名安装，具有特定的编译器版本和软件包集。 You can have many switches and, well, switch between them —whence the name. Create a switch for this semester’s CS 3110 by running this command:

opam switch create cs3110-2023sp ocaml-base-compiler.4.14.0

You might be prompted to run the next command. It won’t matter whether you do or not, because of the very next step we’re going to do (i.e., logging out).
系统可能会提示您运行下一个命令。无论您是否这样做都没关系，因为我们接下来要做的就是（即注销）。

eval $(opam env)

Now we need to make sure your OCaml environment was configured correctly. Logout from your OS (or just reboot). Then re-open your terminal and run this command:
现在我们需要确保您的 OCaml 环境配置正确。从操作系统注销（或重新启动）。然后重新打开终端并运行以下命令：

opam switch list

You should get output like this:
您应该得到如下输出：

#  switch         compiler                    description
→  cs3110-2023sp  ocaml-base-compiler.4.14.0  cs3110-2023sp

There might be other lines if you happen to have done OCaml development before. Here’s what to check for:
如果您之前做过 OCaml 开发，可能还有其他行。以下是要检查的内容：

• You must not get a warning that “The environment is not in sync with the current switch. You should run eval $(opam env)”. If either of the two issues below also occur, you need to resolve this issue first.
  您不得收到“环境与当前交换机不同步”的警告。你应该运行 eval $(opam env) ”。如果同时出现以下两个问题，则需要先解决该问题。

• There must be a right arrow in the first column next to the cs3110-2023sp switch.
  cs3110-2023sp 开关旁边的第一列中必须有一个向右箭头。

• That switch must have the right name and the right compiler version, 4.14.0.
  该开关必须具有正确的名称和正确的编译器版本，4.14.0。

Continue by installing the OPAM packages we need:
继续安装我们需要的 OPAM 包：

opam install -y utop odoc ounit2 qcheck bisect_ppx menhir ocaml-lsp-server ocamlformat ocamlformat-rpc

Make sure to grab that whole line above when you copy it. You will get some output about editor configuration. Unless you intend to use Emacs or Vim for OCaml development, you can safely ignore that output. We’re going to use VS Code as the editor in these instructions, so let’s ignore it.
复制时请务必抓住上面的整行。您将获得一些有关编辑器配置的输出。除非您打算使用 Emacs 或 Vim 进行 OCaml 开发，否则您可以安全地忽略该输出。在这些说明中，我们将使用 VS Code 作为编辑器，所以我们忽略它。

You should now be able to launch utop, the OCaml Universal Toplevel.
您现在应该能够启动 utop，OCaml 通用顶级。

utop

Enter 3110 followed by two semi-colons. Press return. The # is the utop prompt; you do not type it yourself.
输入 3110，后跟两个分号。按回车键。 # 是 utop 提示符；您不自己输入。

# 3110;;
- : int = 3110

Stop to appreciate how lovely 3110 is. Then quit utop. Note that this time you must enter the extra # before the quit directive.
停下来欣赏 3110 是多么可爱。然后退出utop。请注意，这次您必须在 quit 指令之前输入额外的 #。

# #quit;;

A faster way to quit is to type Control+D.
更快的退出方法是按 Control+D。

Double Check OCaml¶ 仔细检查 OCaml ¶

If you’re having any trouble with your installation, follow these double-check instructions. Some of them repeat the tips we provided above, but we’ve put them all here in one place to help diagnose any issues.
如果您在安装时遇到任何问题，请按照这些仔细检查说明进行操作。其中一些重复了我们上面提供的提示，但我们将它们全部放在一处以帮助诊断任何问题。

First, reboot your computer. We need a clean slate for this double check.
首先，重新启动计算机。我们需要一个干净的记录来进行这次双重检查。

Second, run utop, and make sure it works. If it does not, here are some common issues:
其次，运行 utop，并确保其正常工作。如果没有，以下是一些常见问题：

• Are you in the right Unix prompt? On Mac, make sure you are in whatever Unix shell is the default for your Terminal: don’t run bash or zsh or anything else manually to change the shell. On Windows, make sure you are in the Ubuntu app, not PowerShell or Cmd.
  您处于正确的 Unix 提示符中吗？在 Mac 上，确保您使用的是终端默认的 Unix shell：不要手动运行 bash 或 zsh 或其他任何内容来更改 shell。在 Windows 上，确保您使用的是 Ubuntu 应用程序，而不是 PowerShell 或 Cmd。

• Is the OPAM environment set? If utop isn’t a recognized command, run eval $(opam env) then try running utop again. If utop now works, your login shell is somehow not running the right commands to automatically activate the OPAM environment; you shouldn’t have to manually activate the environment with the eval command. Probably something went wrong earlier when you ran the opam init command. To fix it, follow the “redo” instructions below.
  OPAM环境设置了吗？如果 utop 不是可识别的命令，请运行 eval $(opam env) ，然后再次尝试运行 utop。如果 utop 现在可以工作，则说明您的登录 shell 未运行正确的命令来自动激活 OPAM 环境；您不必使用 eval 命令手动激活环境。当您运行 opam init 命令时，可能之前出现了问题。要修复它，请按照下面的“重做”说明进行操作。

• Is your switch listed? Run opam switch list and make sure a switch named cs3110-2023sp is listed, that it has the 4.14.0 compiler, and that it is the active switch (which is indicated with an arrow beside it). If that switch is present but not active, run opam switch cs3110-2023sp then see whether utop works. If that switch is not present, follow the “redo” instructions below.
  您的交换机已列出吗？运行 opam switch list 并确保列出名为 cs3110-2023sp 的开关，它具有 4.14.0 编译器，并且它是活动开关（旁边用箭头指示） 。如果该开关存在但未激活，请运行 opam switch cs3110-2023sp 然后查看 utop 是否工作。如果该开关不存在，请按照下面的“重做”说明进行操作。

Redo Instructions: Remove the OPAM directory by running rm -r ~/.opam. Then go back to the OPAM initialization step in the instructions way above, and proceed forward. Be extra careful to use the exact OPAM commands given above; sometimes mistakes occur when parts of them are omitted. Finally, redo the double check: reboot and see whether utop still works.
重做说明：通过运行 rm -r ~/.opam 删除 OPAM 目录。然后按照上面的说明回到OPAM初始化步骤，然后继续。使用上面给出的确切 OPAM 命令时要格外小心；有时，由于省略了部分内容，就会出现错误。最后，重做双重检查：重新启动并查看 utop 是否仍然有效。

Visual Studio Code¶ Visual Studio Code ¶

Visual Studio Code is a great choice as a code editor for OCaml. (Though if you are already a power user of Emacs or Vim those are great, too.)
Visual Studio Code 是 OCaml 代码编辑器的绝佳选择。 （不过，如果您已经是 Emacs 或 Vim 的高级用户，那么这些也很棒。）

First, download and install Visual Studio Code (henceforth, VS Code). Launch VS Code. Open the extensions pane, either by going to View → Extensions, or by clicking on the icon for it in the column of icons on the left — it looks like four little squares, the top-right of which is separated from the other three.
首先，下载并安装 Visual Studio Code（以下简称 VS Code）。启动 VS 代码。打开扩展窗格，可以转到“视图”→“扩展”，或者单击左侧图标栏中的图标 - 它看起来像四个小方块，右上角与其他三个小方块分开。

Second, follow one of these steps if you are on Windows or Mac:
其次，如果您使用的是 Windows 或 Mac，请执行以下步骤之一：

• Windows only: Install the “WSL” extension. Second, open a WSL window by using the command “WSL: New WSL Window”. The first time you do this, it will install some additional software. After that completes, you will see a green “WSL: Ubuntu” indicator in the bottom-left of the VS Code window. Make sure that you see “WSL: Ubuntu” there before proceeding with the instructions below. If you see just an icon that looks like _>^< then click it, and choose “New WSL Window” from the Command Palette that opens.
  仅限 Windows：安装“WSL”扩展。其次，使用命令“WSL: New WSL Window”打开 WSL 窗口。第一次执行此操作时，它将安装一些附加软件。完成后，您将在 VS Code 窗口左下角看到一个绿色的“WSL：Ubuntu”指示器。在继续执行以下说明之前，请确保您在那里看到“WSL：Ubuntu”。如果您只看到一个类似 _> ^< 的图标，请单击它，然后从打开的命令面板中选择“新建 WSL 窗口”。

• Mac only: Open the Command Palette and type “shell command” to find the “Shell Command: Install ‘code’ command in PATH” command. Run it.
  仅限 Mac：打开命令面板并输入“shell 命令”以查找“Shell 命令：在 PATH 中安装‘code’命令”命令。运行。

Third, regardless of your OS, close any open terminals — or just logout or reboot — to let the new path settings take effect, so that you will later be able to launch VS Code from the terminal.
第三，无论您使用哪种操作系统，请关闭所有打开的终端（或者只是注销或重新启动）以使新路径设置生效，以便您稍后能够从终端启动 VS Code。

Fourth, again open the VS Code extensions pane. Search for and install the “OCaml Platform” extension from OCaml Labs. Be careful to install the extension with exactly that name. (If you happen to note a “build failing” icon on the extension’s page, don’t be concerned.)
第四，再次打开 VS Code 扩展窗格。从 OCaml Labs 搜索并安装“OCaml Platform”扩展。请小心安装具有完全相同名称的扩展。 （如果您碰巧在扩展程序页面上注意到“构建失败”图标，请不要担心。）

Double Check VS Code¶
仔细检查 VS 代码 ¶

Let’s make sure VS Code’s OCaml support is working.
让我们确保 VS Code 的 OCaml 支持正常工作。

• Reboot your computer again. (Yeah, that really shouldn’t be necessary. But it will detect so many potential mistakes now that it’s worth the effort.)
  再次重新启动计算机。 （是的，这确实没有必要。但它会检测到很多潜在的错误，所以值得付出努力。）

• Open a fresh new Unix shell. Windows: remember that’s the Ubuntu, not PowerShell or Cmd. Mac: remember that you shouldn’t be manually switching to a different shell by typing zsh or bash.
  打开一个全新的 Unix shell。 Windows：记住那是 Ubuntu，而不是 PowerShell 或 Cmd。 Mac：请记住，您不应该通过键入 zsh 或 bash 手动切换到不同的 shell。

• Navigate to a directory of your choice, preferably a subdirectory of your home directory. For example, you might create a directory for your 3110 work inside your home directory:
  导航到您选择的目录，最好是主目录的子目录。例如，您可以在主目录中为 3110 工作创建一个目录：

  mkdir ~/3110
  cd ~/3110
  

  In that directory open VS Code by running:
  在该目录中运行以下命令打开 VS Code：

  code .
  

  Go to File → New File. Save the file with the name test.ml. VS Code should give it an orange camel icon.
  转到文件 → 新建文件。使用名称 test.ml 保存文件。 VS Code 应该给它一个橙色的骆驼图标。

• Type the following OCaml code then press Return/Enter:
  输入以下 OCaml 代码，然后按 Return/Enter：

  let x : int = 3110
  

  As you type, VS Code should colorize the syntax, suggest some completions, and add a little annotation above the line of code. Try changing the int you typed to string. A squiggle should appear under 3110. Hover over it to see the error message. Go to View → Problems to see it there, too. Add double quotes around the integer to make it a string, and the problem will go away.
  当您键入时，VS Code 应该对语法进行着色，建议一些补全，并在代码行上方添加一些注释。尝试将您输入的 int 更改为 string 。 3110 下应出现一条曲线。将鼠标悬停在其上即可查看错误消息。也可以转到查看 → 问题来查看它。在整数周围添加双引号以使其成为字符串，问题就会消失。

If you don’t observe those behaviors, something is wrong with your install. Here’s how to proceed:
如果您没有观察到这些行为，则表明您的安装有问题。以下是如何进行：

• Make sure that, from the same Unix prompt as which you launched VS Code, you can successfully complete the double-check instructions for your OPAM switch: can you run utop? is the right switch active? If not, that’s the problem you need to solve first. Then return to the VS Code issue. It might be fixed now.
  确保从启动 VS Code 的同一 Unix 提示符中，您可以成功完成 OPAM 开关的双重检查指令：您可以运行 utop 吗？右侧开关是否处于活动状态？如果没有，这就是您需要首先解决的问题。然后回到VS Code的问题。现在可能已经修复了。

• If you’re on WSL and VS Code does add syntax highlighting but does not add squiggles as described above, and/or you get an error about “Sandbox initialization failed”, then double-check that you see a green “WSL” indicator in the bottom left of the VS Code window. If you do not, make sure you installed the “Remote - WSL” extension as described above, and that you are launching VS Code from Ubuntu rather than PowerShell or from the Windows GUI.
  如果您使用 WSL 并且 VS Code 确实添加了语法突出显示，但没有添加如上所述的波浪线，和/或您收到有关“沙箱初始化失败”的错误，请仔细检查您是否在VS Code 窗口的左下角。如果没有，请确保您安装了如上所述的“Remote - WSL”扩展，并且从 Ubuntu 而不是 PowerShell 或 Windows GUI 启动 VS Code。

If you’re still stuck with an issue, try uninstalling VS Code, rebooting, and re-doing all the install instructions above from scratch. Pay close attention to any warnings or errors.
如果您仍然遇到问题，请尝试卸载 VS Code、重新启动并从头开始重新执行上述所有安装说明。密切注意任何警告或错误。

VS Code Settings¶ VS 代码设置 ¶

We recommend tweaking a few editor settings. Open the user settings JSON file by (i) going to View → Command Palette, (ii) typing “user settings json”, and (iii) selecting Open User Settings (JSON). Copy and paste these settings into the window:
我们建议调整一些编辑器设置。通过以下方式打开用户设置 JSON 文件：(i) 转至查看 → 命令面板，(ii) 键入“用户设置 json”，以及 (iii) 选择打开用户设置 (JSON)。将这些设置复制并粘贴到窗口中：

{
    "editor.tabSize": 2,
    "editor.rulers": [ 80 ],
    "editor.formatOnSave": true
}

Save the file and close the tab.
保存文件并关闭选项卡。

Using VS Code Collaboratively¶
协作使用 VS Code ¶

VS Code’s Live Share extension makes it easy and fun to collaborate on code with other humans. You can edit code together like collaborating inside a Google Doc. It even supports a shared voice channel, so there’s no need to spin up a separate Zoom call. To install Live Share:
VS Code 的 Live Share 扩展让与其他人协作编写代码变得简单而有趣。您可以一起编辑代码，就像在 Google 文档中协作一样。它甚至支持共享语音通道，因此无需启动单独的 Zoom 通话。要安装 Live Share：

• Open the Extensions page in VS Code. Search for “Live Share Extension Pack”. Install it.
  在 VS Code 中打开扩展页面。搜索“Live Share 扩展包”。安装它。

• The first time you use Live Share, you will be prompted to login. If you are a Cornell student, choose to login with your Microsoft account, not GitHub. Enter your Cornell NetID email, e.g., your_netid@cornell.edu. That will take you to Cornell’s login site. Use the password associated with your NetID.
  第一次使用 Live Share 时，系统会提示您登录。如果您是康奈尔大学的学生，请选择使用您的 Microsoft 帐户登录，而不是 GitHub。输入您的 Cornell NetID 电子邮件，例如 your_netid@cornell.edu 。这将带您进入康奈尔大学的登录网站。使用与您的 NetID 关联的密码。

To collaborate with Live Share:
要与 Live Share 协作：

• The host starts the Live Share session. That generates a URL. Send the URL to the guests however you like (DM, email, etc.).
  主持人启动 Live Share 会话。这会生成一个 URL。以您喜欢的方式（DM、电子邮件等）将 URL 发送给客人。

• The guest puts that URL into a browser or directly into VS Code, and connects to the shared programming session.
  来宾将该 URL 放入浏览器或直接放入 VS Code 中，然后连接到共享编程会话。

1.2.1. The Features of OCaml¶
1.2.1. OCaml 的特点 ¶

OCaml is a  OCaml 是一个statically-typed 静态类型 and type-safe 类型安全 programming language. A statically-typed language detects type errors at compile time; if a type error is detected, the language won’t allow execution of the program. A type-safe language limits which kinds of operations can be performed on which kinds of data. In practice, this prevents a lot of silly errors (e.g., treating an integer as a function) and also prevents a lot of security problems: over half of the reported break-ins at the Computer Emergency Response Team (CERT, a US government agency tasked with cybersecurity) were due to buffer overflows, something that’s impossible in a type-safe language.
编程语言。静态类型语言在编译时检测类型错误；如果检测到类型错误，该语言将不允许执行该程序。类型安全语言限制可以对哪种数据执行哪种操作。实际上，这可以防止许多愚蠢的错误（例如，将整数视为函数），并且还可以防止许多安全问题：计算机紧急响应小组（CERT，美国政府机构）报告的入侵事件中有一半以上负责网络安全的任务）是由于缓冲区溢出造成的，这在类型安全语言中是不可能的。
OCaml 是一种静态类型和类型安全的编程语言。静态类型语言在编译时检测类型错误；如果检测到类型错误，该语言将不允许执行该程序。类型安全语言限制可以对哪种数据执行哪种操作。实际上，这可以防止许多愚蠢的错误（例如，将整数视为函数），并且还可以防止许多安全问题：计算机紧急响应小组（CERT，美国政府机构）报告的入侵事件中有一半以上负责网络安全的任务）是由于缓冲区溢出造成的，这在类型安全语言中是不可能的。

Some languages, like Python and Racket, are type-safe but dynamically typed. That is, type errors are caught only at run time. Other languages, like C and C++, are statically typed but not type safe: they check for some type errors, but don’t guarantee the absence of all
C 和 C++ 是静态类型的，但不是类型安全的：它们检查某些类型错误，但不保证不存在所有类型错误type errors. That is, there’s no guarantee that a type error won’t occur at run time. And still other languages, like Java, use a combination of static and dynamic typing to achieve type safety.
有些语言（例如 Python 和 Racket）是类型安全的，但是是动态类型的。也就是说，类型错误仅在运行时才会被捕获。其他语言（例如 C 和 C++）是静态类型的，但不是类型安全的：它们检查某些类型错误，但不保证不存在所有类型错误。也就是说，不能保证在运行时不会发生类型错误。还有其他语言，如 Java，使用静态和动态类型的组合来实现类型安全。

OCaml supports a number of advanced features, some of which you will have encountered before, and some of which are likely to be new:
OCaml 支持许多高级功能，其中一些您以前会遇到过，而另一些可能是新的：

• Algebraic datatypes: You can build sophisticated data structures in OCaml easily, without fussing with pointers and memory management. Pattern matching 模式匹配—a feature we’ll soon learn about that enables examining the shape of a data structure—makes them even more convenient.
  代数数据类型：您可以在 OCaml 中轻松构建复杂的数据结构，而无需担心指针和内存管理。模式匹配——我们很快就会了解的一个功能，可以检查数据结构的形状——使它们变得更加方便。

• Type inference 类型推断: You do not have to write type information down everywhere. The compiler automatically figures out most types. This can make the code easier to read and maintain.
  类型推断：您不必在任何地方都写下类型信息。编译器会自动找出大多数类型。这可以使代码更易于阅读和维护。

• Parametric polymorphism: 参数多态性： Functions and data structures can be parameterized over types. This is crucial for being able to re-use code.
  函数和数据结构可以通过类型进行参数化。这对于能够重用代码至关重要。
  参数多态性：函数和数据结构可以通过类型进行参数化。这对于能够重用代码至关重要。

• Garbage collection: Automatic memory management relieves you from the burden of memory allocation and deallocation, a common source of bugs in languages such as C.
  垃圾收集：自动内存管理使您摆脱内存分配和释放的负担，这是 C 等语言中错误的常见来源。

• Modules: OCaml makes it easy to structure large systems through the use of modules. Modules are used to encapsulate implementations behind interfaces. OCaml goes well beyond the functionality of most languages with modules by providing functions (called functors) that manipulate modules.
  模块：OCaml 通过使用模块可以轻松构建大型系统。模块用于封装接口后面的实现。 OCaml 通过提供操作模块的函数（称为函子），远远超出了大多数带有模块的语言的功能。

1.2.2. OCaml in Industry¶
1.2.2. 工业中的 OCaml ¶

OCaml and other functional languages are nowhere near as popular as Python, C, or Java. OCaml’s real strength lies in language manipulation (i.e., compilers, analyzers, verifiers, provers, etc.). This is not surprising, because OCaml evolved from the domain of theorem proving.
OCaml 和其他函数式语言远不如 Python、C 或 Java 流行。 OCaml 的真正优势在于语言操作（即编译器、分析器、验证器、证明器等）。这并不奇怪，因为 OCaml 是从定理证明领域发展而来的。

That’s not to say that functional languages aren’t used in industry. There are many industry projects using OCaml and Haskell, among other languages. Yaron Minsky (Cornell PhD ‘02) even wrote a paper about using OCaml in the financial industry. It explains how the features of OCaml make it a good choice for quickly building complex software that works.
这并不是说函数式语言没有在工业中使用。有许多行业项目使用 OCaml 和 Haskell 等语言。 Yaron Minsky（康奈尔大学博士 02）甚至写了一篇关于在金融行业使用 OCaml 的论文。它解释了 OCaml 的功能如何使其成为快速构建可用的复杂软件的良好选择。

1.5.1. Terms and Concepts¶
1.5.1. 术语和概念 ¶

• dynamic typing 动态类型

• first-class functions 一流的功能

• functional programming languages
  函数式编程语言

• immutability 不变性

• Lisp 口齿不清

• ML

• OCaml 奥卡米尔

• referential transparency 参考透明度

• side effects 副作用 副作用

• state 状态

• static typing 静态类型

• type safety 类型安全

1.5.2. Further Reading¶ 1.5.2. 延伸阅读 ¶

• Introduction to Objective Caml, chapters 1 and 2, a freely available textbook that is recommended for this course
  Objective Caml 简介，第 1 章和第 2 章，本课程推荐的免费教科书

• OCaml from the Very Beginning, chapter 1, a textbook that is very gentle and recommended for this course. The PDF and HTML formats of the book are free of charge.
  OCaml 从头开始​​，第 1 章，一本非常温和的教科书，推荐用于本课程。本书的 PDF 和 HTML 格式都是免费的。

• A guided tour [of OCaml]: chapter 1 of Real World OCaml, a book written by some Cornellians that some students might enjoy reading
  [OCaml] 导览：《真实世界 OCaml》的第一章，这是一本由一些康奈尔人写的书，一些学生可能会喜欢阅读

• The history of Standard ML: though it focuses on the SML variant of the ML language, it’s relevant to OCaml
  标准 ML 的历史：虽然它重点关注 ML 语言的 SML 变体，但它与 OCaml 相关

• The value of values: a lecture by the designer of Clojure (a modern dialect of Lisp) on how the time of imperative programming has passed
  价值观的价值：Clojure（Lisp 的现代方言）设计者关于命令式编程时代如何过去的讲座

• Teach yourself programming in 10 years: an essay by a Director of Research at Google that puts the time required to become an educated programmer into perspective
  10 年内自学编程：谷歌研究总监的一篇文章，阐述了成为受过教育的程序员所需的时间

2.1.1. Types and values¶
2.1.1. 类型和值 ¶

You can enter expressions into the OCaml toplevel. End an expression with a double semi-colon ;; and press the return key. OCaml will then evaluate the expression, tell you the resulting value, and the value’s type. For example:
您可以在 OCaml 顶层输入表达式。以双分号 ;; 结束表达式，然后按回车键。然后 OCaml 将计算表达式，告诉您结果值以及值的类型。例如：

# 42;;
- : int = 42

Let’s dissect that response from utop, reading right to left:
让我们从右向左仔细阅读 utop 的响应：

• 42 is the value.
  42 是值。

• int is the type of the value.
  int 是值的类型。

• The value was not given a name, hence the symbol -.
  该值未指定名称，因此使用符号 - 。

That utop interaction was “hardcoded” as part of this book. We had to type in all the characters: the #, the -, etc. But the infrastructure used to write this book actually enables us to write code that is evaluated by OCaml at the time the book is translated into HTML or PDF. From now on, that’s usually what we will do. It looks like this:
utop 交互被“硬编码”为本书的一部分。我们必须输入所有字符： # 、 - 等。但是用于编写本书的基础设施实际上使我们能够编写由 OCaml 在书被翻译成 HTML 或 PDF 的时间。从现在开始，这就是我们通常会做的事情。它看起来像这样：

42

- : int = 42

The first code block with the 42 in it is the code we asked OCaml to run. If you want to enter that into utop, you can copy and paste it. There’s an icon in the top right of the block to do that easily. Just remember to add the double semicolon at the end. The second code block, which is indented a little, is the output from OCaml as the book was being translated.
第一个带有 42 的代码块是我们要求 OCaml 运行的代码。如果您想将其输入到 utop 中，可以复制并粘贴它。该块的右上角有一个图标可以轻松完成此操作。只需记住在末尾添加双分号即可。第二个代码块稍微缩进了一点，是翻译本书时 OCaml 的输出。

You can bind values to names with a let definition, as follows:
您可以使用 let 定义将值绑定到名称，如下所示：

let x = 42

val x : int = 42

Again, let’s dissect that response, this time reading left to right:
再次，让我们剖析该响应，这次从左到右阅读：

• A value was bound to a name, hence the val keyword.
  值绑定到名称，因此有 val 关键字。

• x is the name to which the value was bound.
  x 是值绑定到的名称。

• int is the type of the value.
  int 是值的类型。

• 42 is the value.
  42 是值。

You can pronounce the entire output as “x has type int and equals 42.”
您可以将整个输出发音为“ x 具有类型 int 且等于 42 ”。

2.1.2. Functions¶ 2.1.2. 函数 ¶

A function can be defined at the toplevel using syntax like this:
可以使用如下语法在顶层定义函数：

let increment x = x + 1

val increment : int -> int = <fun>

Let’s dissect that response:
让我们剖析一下这个回应：

• increment is the identifier to which the value was bound.
  increment 是值绑定到的标识符。

• int -> int is the type of the value. This is the type of functions that take an int as input and produce an int as output. Think of the arrow -> as a kind of visual metaphor for the transformation of one value into another value—which is what functions do.
  int -> int 是值的类型。这是一种将 int 作为输入并生成 int 作为输出的函数。将箭头 -> 视为一种将一个值转换为另一个值的视觉隐喻——这就是函数的作用。

• The value is a function, which the toplevel chooses not to print (because it has now been compiled and has a representation in memory that isn’t easily amenable to pretty printing). Instead, the toplevel prints <fun>, which is just a placeholder.
  该值是一个函数，顶层选择不打印它（因为它现在已经被编译并且在内存中具有不容易进行漂亮打印的表示）。相反，顶层打印 <fun> ，这只是一个占位符。

You can “call” functions with syntax like this:
您可以使用如下语法“调用”函数：

increment 0

- : int = 1

increment(21)

- : int = 22

increment (increment 5)

- : int = 7

But in OCaml the usual vocabulary is that we “apply” the function rather than “call” it.
但在 OCaml 中，通常的词汇是我们“应用”函数而不是“调用”它。

Note how OCaml is flexible about whether you write the parentheses or not, and whether you write whitespace or not. One of the challenges of first learning OCaml can be figuring out when parentheses are actually required. So if you find yourself having problems with syntax errors, one strategy is to try adding some parentheses. The preferred style, though, is usually to omit parentheses when they are not needed. So, increment 21 is better than increment(21)
请注意 OCaml 在是否写括号以及是否写空格方面是如何灵活的。首次学习 OCaml 的挑战之一可能是弄清楚何时实际需要括号。因此，如果您发现自己遇到语法错误问题，一种策略是尝试添加一些括号。不过，首选的样式通常是在不需要时省略括号。因此， increment 21 优于 increment(21) .

2.1.3. Loading code in the toplevel¶
2.1.3. 在顶层加载代码 ¶

In addition to allowing you to define functions, the toplevel will also accept directives that are not OCaml code but rather tell the toplevel itself to do something. All directives begin with the # character. Perhaps the most common directive is #use, which loads all the code from a file into the toplevel, just as if you had typed the code from that file into the toplevel.
除了允许您定义函数之外，顶层还将接受不是 OCaml 代码的指令，而是告诉顶层本身执行某些操作。所有指令均以 # 字符开头。也许最常见的指令是 #use ，它将文件中的所有代码加载到顶层，就像您将该文件中的代码键入到顶层一样。

For example, suppose you create a file named mycode.ml. In that file put the following code:
例如，假设您创建一个名为 mycode.ml 的文件。在该文件中放入以下代码：

let inc x = x + 1

Start the toplevel. Try entering the following expression, and observe the error:
开始顶层。尝试输入以下表达式，并观察错误：

inc 3

File "[7]", line 1, characters 0-3:
1 | inc 3
    ^^^
Error: Unbound value inc
Hint: Did you mean incr?

The error occurs because the toplevel does not yet know anything about a function named inc. Now issue the following directive to the toplevel:
发生错误是因为顶层还不知道有关名为 inc 的函数的任何信息。现在向顶层发出以下指令：

# #use "mycode.ml";;

Note that the first # character above indicates the toplevel prompt to you. The second # character is one that you type to tell the toplevel that you are issuing a directive. Without that character, the toplevel would think that you are trying to apply a function named use.
请注意，上面的第一个 # 字符向您指示顶级提示。第二个 # 字符是您键入的一个字符，用于告诉顶层您正在发出指令。如果没有该字符，顶层会认为您正在尝试应用名为 use 的函数。

Now try again: 现在再试一次：

inc 3

- : int = 4

2.1.4. Workflow in the toplevel¶
2.1.4. 顶层工作流程 ¶

The best workflow when using the toplevel with code stored in files is:
将顶层与存储在文件中的代码一起使用时的最佳工作流程是：

• Edit the code in the file.
  编辑文件中的代码。

• Load the code in the toplevel with #use.
  使用 #use 在顶层加载代码。

• Interactively test the code.
  交互式测试代码。

• Exit the toplevel. Warning: do not skip this step.
  退出顶层。警告：不要跳过此步骤。

2.2.1. Storing code in files¶
2.2.1. 在文件中存储代码 ¶

Open a terminal, create a new directory, and open VS Code in that directory. For example, you could use the following commands:
打开终端，创建一个新目录，然后在该目录中打开 VS Code。例如，您可以使用以下命令：

$ mkdir hello-world
$ cd hello-world

Use VS Code to create a new file named hello.ml. Enter the following code into the file:
使用 VS Code 创建一个名为 hello.ml 的新文件。在文件中输入以下代码：

let _ = print_endline "Hello world!"

The let _ = above means that we don’t care to give a name (hence the “blank” or underscore) to code on the right-hand side of the =.
上面的 let _ = 意味着我们不关心为 = 右侧的代码命名（因此是“空白”或下划线）。

Save the file and return to the command line. Compile the code:
保存文件并返回到命令行。编译代码：

$ ocamlc -o hello.byte hello.ml

The compiler is named ocamlc. The -o hello.byte option says to name the output executable hello.byte. The executable contains compiled OCaml bytecode. In addition, two other files are produced, hello.cmi and hello.cmo. We don’t need to be concerned with those files for now. Run the executable:
编译器名为 ocamlc 。 -o hello.byte 选项表示将输出可执行文件命名为 hello.byte 。可执行文件包含已编译的 OCaml 字节码。此外，还会生成另外两个文件： hello.cmi 和 hello.cmo 。我们暂时不需要关心这些文件。运行可执行文件：

$ ./hello.byte

It should print Hello world! and terminate.
它应该打印 Hello world! 并终止。

Now change the string that is printed to something of your choice. Save the file, recompile, and rerun. Try making the code print multiple lines.
现在将打印的字符串更改为您选择的字符串。保存文件，重新编译并重新运行。尝试让代码打印多行。

This edit-compile-run cycle between the editor and the command line is something that might feel unfamiliar if you’re used to working inside IDEs like Eclipse. Don’t worry; it will soon become second nature.
如果您习惯在 Eclipse 等 IDE 中工作，那么编辑器和命令行之间的编辑-编译-运行循环可能会让您感到陌生。不用担心;它很快就会成为第二天性。

Now let’s clean up all those generated files:
现在让我们清理所有生成的文件：

$ rm hello.byte hello.cmi hello.cmo

2.2.2. What about Main?¶
2.2.2. 主要呢？ ¶

Unlike C or Java, OCaml programs do not need to have a special function named main that is invoked to start the program. The usual idiom is just to have the very last definition in a file serve as the main function that kicks off whatever computation is to be done.
与 C 或 Java 不同，OCaml 程序不需要调用名为 main 的特殊函数来启动程序。通常的习惯用法是将文件中的最后一个定义作为主函数，启动要完成的任何计算。

2.2.3. Dune¶ 2.2.3. 沙丘 ¶

In larger projects, we don’t want to run the compiler or clean up manually. Instead, we want to use a build system to automatically find and link in libraries. OCaml has a legacy build system called ocamlbuild, and a newer build system called Dune. Similar systems include make, which has long been used in the Unix world for C and other languages; and Gradle, Maven, and Ant, which are used with Java.
在较大的项目中，我们不想运行编译器或手动清理。相反，我们希望使用构建系统来自动查找和链接库。 OCaml 有一个名为 ocamlbuild 的旧构建系统和一个名为 Dune 的较新构建系统。类似的系统包括 make ，它长期以来在 Unix 世界中用于 C 和其他语言；以及与 Java 一起使用的 Gradle、Maven 和 Ant。

A Dune project is a directory (and its subdirectories) that contain OCaml code you want to compile. The root of a project is the highest directory in its hierarchy. A project might rely on external packages providing additional code that is already compiled. Usually, packages are installed with OPAM, the OCaml Package Manager.
Dune 项目是一个目录（及其子目录），其中包含要编译的 OCaml 代码。项目的根目录是其层次结构中的最高目录。项目可能依赖于提供已编译的附加代码的外部包。通常，包是通过 OPAM（OCaml 包管理器）安装的。

Each directory in your project can contain a file named dune. That file describes to Dune how you want the code in that directory (and subdirectories) to be compiled. Dune files use a functional-programming syntax descended from LISP called s-expressions, in which parentheses are used to show nested data that form a tree, much like HTML tags do. The syntax of Dune files is documented in the Dune manual.
项目中的每个目录都可以包含一个名为 dune 的文件。该文件向 Dune 描述了您希望如何编译该目录（和子目录）中的代码。 Dune 文件使用源自 LISP 的函数编程语法（称为 s-表达式），其中括号用于显示形成树的嵌套数据，就像 HTML 标签一样。 Dune 文件的语法记录在 Dune 手册中。

Here is a small example of how to use Dune. In the same directory as hello.ml, create a file named dune and put the following in it:
这是一个如何使用 Dune 的小示例。在与 hello.ml 相同的目录中，创建一个名为 dune 的文件，并将以下内容放入其中：

(executable
 (name hello))

That declares an executable (a program that can be executed) whose main file is hello.ml.
它声明了一个可执行文件（可以执行的程序），其主文件是 hello.ml 。

Also create a file named dune-project and put the following in it:
另外创建一个名为 dune-project 的文件并在其中放入以下内容：

(lang dune 3.4)

That tells Dune that this project uses Dune version 3.4, which was current at the time this version of the textbook was released. This  这project 项目 file is needed in the root directory of every source tree that you want to compile with Dune. In general, you’ll have a
您想要使用 Dune 编译的每个源代码树的根目录中都需要文件。一般来说，您将有一个dune file in every subdirectory of the source tree but only one
文件位于源树的每个子目录中，但只有一个dune-project file at the root.
文件在根目录下。
这告诉 Dune 该项目使用 Dune 3.4 版本，该版本在该版本的教科书发布时是最新的。您想要使用 Dune 编译的每个源代码树的根目录中都需要此项目文件。一般来说，源树的每个子目录中都会有一个 dune 文件，但根目录下只有一个 dune-project 文件。

Then run this command from the terminal:
然后从终端运行此命令：

$ dune build hello.exe

Note that the .exe extension is used on all platforms by Dune, not just on Windows. That causes Dune to build a native executable rather than a bytecode executable.
请注意， .exe 扩展名在 Dune 的所有平台上使用，而不仅仅是在 Windows 上。这会导致 Dune 构建本机可执行文件而不是字节码可执行文件。

Dune will create a directory _build and compile our program inside it. That’s one benefit of the build system over directly running the compiler: instead of polluting your source directory with a bunch of generated files, they get cleanly created in a separate directory. Inside _build there are many files that get created by Dune. Our executable is buried a couple of levels down:
Dune 将创建一个目录 _build 并在其中编译我们的程序。这是构建系统相对于直接运行编译器的好处之一：它们不会用一堆生成的文件污染源目录，而是在单独的目录中干净地创建它们。 _build 内部有许多由 Dune 创建的文件。我们的可执行文件被埋藏在下面几层：

$ _build/default/hello.exe
Hello world!

But Dune provides a shortcut to having to remember and type all of that. To build and execute the program in one step, we can simply run:
但《沙丘》提供了一条捷径，让您无需记住并输入所有这些内容。要一步构建并执行程序，我们只需运行：

$ dune exec ./hello.exe
Hello world!

Finally, to clean up all the compiled code we just run:
最后，为了清理我们刚刚运行的所有编译代码：

$ dune clean

That removes the _build directory, leaving just your source code.
这将删除 _build 目录，只留下源代码。

2.3.1. Primitive Types and Values¶
2.3.1. 原始类型和值 ¶

The primitive types are the built-in and most basic types: integers, floating-point numbers, characters, strings, and booleans. They will be recognizable as similar to primitive types from other programming languages.
基本类型是内置的最基本类型：整数、浮点数、字符、字符串和布尔值。它们将被识别为与其他编程语言中的原始类型类似。

Type int: Integers. OCaml integers are written as usual: 1, 2, etc. The usual operators are available: +, -, *, /, and mod. The latter two are integer division and modulus:
类型 int ：整数。 OCaml 整数的书写方式与往常一样： 1 、 2 等。常用运算符可用： + 、 - 、 * 、 / 和 mod 。后两者是整数除法和模数：

65 / 60

- : int = 1

65 mod 60

- : int = 5

65 / 0

Exception: Division_by_zero.
Raised by primitive operation at unknown location
Called from Stdlib__Fun.protect in file "fun.ml", line 33, characters 8-15
Re-raised at Stdlib__Fun.protect in file "fun.ml", line 38, characters 6-52
Called from Topeval.load_lambda in file "toplevel/byte/topeval.ml", line 89, characters 4-150

OCaml integers range from −262$-2^{62}$ to 262−1$2^{62}-1$ on modern platforms. They are implemented with 64-bit machine words, which is the size of a register on 64-bit processor. But one of those bits is “stolen” by the OCaml implementation, leading to a 63-bit representation. That bit is used at run time to distinguish integers from pointers. For applications that need true 64-bit integers, there is an Int64 module in the standard library. And for applications that need arbitrary-precision integers, there is a separate Zarith library. But for most purposes, the built-in int type suffices and offers the best performance.
在现代平台上，OCaml 整数的范围是从 −262$-2^{62}$ 到 262−1$2^{62}-1$ 。它们是用 64 位机器字实现的，这是 64 位处理器上寄存器的大小。但其中一位被 OCaml 实现“窃取”，从而产生 63 位表示。该位在运行时用于区分整数和指针。对于需要真正 64 位整数的应用程序，标准库中有一个 Int64 模块。对于需要任意精度整数的应用程序，有一个单独的 Zarith 库。但对于大多数用途，内置的 int 类型就足够了，并提供最佳性能。

Type float: Floating-point numbers. OCaml floats are IEEE 754 double-precision floating-point numbers. Syntactically, they must always contain a dot—for example, 3.14 or 3.0 or even 3.. The last is a float; if you write it as 3, it is instead an int:
类型 float ：浮点数。 OCaml 浮点数是 IEEE 754 双精度浮点数。从语法上讲，它们必须始终包含一个点，例如 3.14 或 3.0 甚至 3. 。最后一个是 float ；如果你把它写成 3 ，它就会变成 int ：

3.

- : float = 3.

3

- : int = 3

OCaml deliberately does not support operator overloading, Arithmetic operations on floats are written with a dot after them. For example, floating-point multiplication is written *. not *:
OCaml 故意不支持运算符重载，浮点上的算术运算在其后写有一个点。例如，浮点乘法写作 *. 而不是 * ：

3.14 *. 2.

- : float = 6.28

3.14 * 2.

File "[7]", line 1, characters 0-4:
1 | 3.14 * 2.
    ^^^^
Error: This expression has type float but an expression was expected of type
         int

OCaml will not automatically convert between int and float. If you want to convert, there are two built-in functions for that purpose: int_of_float and float_of_int.
OCaml 不会自动在 int 和 float 之间进行转换。如果您想进行转换，有两个内置函数可用于此目的： int_of_float 和 float_of_int 。

3.14 *. (float_of_int 2)

- : float = 6.28

As in any language, the floating-point representation is approximate. That can lead to rounding errors:
与任何语言一样，浮点表示是近似的。这可能会导致舍入错误：

0.1 +. 0.2

- : float = 0.300000000000000044

The same behavior can be observed in Python and Java, too. If you haven’t encountered this phenomenon before, here’s a basic guide to floating-point representation that you might enjoy reading.
在 Python 和 Java 中也可以观察到相同的行为。如果您以前没有遇到过这种现象，那么您可能会喜欢阅读以下浮点表示的基本指南。

Type bool: Booleans. The boolean values are written true and false. The usual short-circuit conjunction && and disjunction || operators are available.
类型 bool ：布尔值。布尔值写作 true 和 false 。可以使用常用的短路合取 && 和析取 || 运算符。

Type char: Characters. Characters are written with single quotes, such as 'a', 'b', and 'c'. They are represented as bytes —that is, 8-bit integers— in the ISO 8859-1 ISO 8859-1 “Latin-1” encoding. The first half of the characters in that range are the standard ASCII characters. You can convert characters to and from integers with char_of_int and int_of_char.
类型 char ：字符。字符用单引号书写，例如 'a' 、 'b' 和 'c' 。它们在 ISO 8859-1“Latin-1”编码中表示为字节（即 8 位整数）。该范围内的前半部分字符是标准 ASCII 字符。您可以使用 char_of_int 和 int_of_char 将字符与整数相互转换。

Type string: Strings. Strings are sequences of characters. They are written with double quotes, such as "abc". The string concatenation operator is ^:
类型 string ：字符串。字符串是字符序列。它们用双引号书写，例如 "abc" 。字符串连接运算符是 ^ ：

"abc" ^ "def"

- : string = "abcdef"

Object-oriented languages often provide an overridable method for converting objects to strings, such as toString() in Java or __str__() in Python. But most OCaml values are not objects, so another means is required to convert to strings. For three of the primitive types, there are built-in functions: string_of_int, string_of_float, string_of_bool. Strangely, there is no string_of_char, but the library function String.make can be used to accomplish the same goal.
面向对象的语言通常提供可重写的方法来将对象转换为字符串，例如 Java 中的 toString() 或 Python 中的 __str__() 。但大多数 OCaml 值都不是对象，因此需要另一种方法来转换为字符串。对于三种基本类型，有内置函数： string_of_int 、 string_of_float 、 string_of_bool 。奇怪的是，没有 string_of_char ，但是可以使用库函数 String.make 来完成相同的目标。

string_of_int 42

- : string = "42"

String.make 1 'z'

- : string = "z"

Likewise, for the same three primitive types, there are built-in functions to convert from a string if possible: int_of_string, float_of_string, and bool_of_string.
同样，对于相同的三种基元类型，如果可能的话，有内置函数可以从字符串进行转换： int_of_string 、 float_of_string 和 bool_of_string 。

int_of_string "123"

- : int = 123

int_of_string "not an int"

Exception: Failure "int_of_string".
Raised by primitive operation at unknown location
Called from Stdlib__Fun.protect in file "fun.ml", line 33, characters 8-15
Re-raised at Stdlib__Fun.protect in file "fun.ml", line 38, characters 6-52
Called from Topeval.load_lambda in file "toplevel/byte/topeval.ml", line 89, characters 4-150

There is no char_of_string, but the individual characters of a string can be accessed by a 0-based index. The indexing operator is written with a dot and square brackets:
没有 char_of_string ，但可以通过基于 0 的索引来访问字符串的各个字符。索引运算符用点和方括号编写：

"abc".[0]

- : char = 'a'

"abc".[1]

- : char = 'b'

"abc".[3]

Exception: Invalid_argument "index out of bounds".
Raised by primitive operation at unknown location
Called from Stdlib__Fun.protect in file "fun.ml", line 33, characters 8-15
Re-raised at Stdlib__Fun.protect in file "fun.ml", line 38, characters 6-52
Called from Topeval.load_lambda in file "toplevel/byte/topeval.ml", line 89, characters 4-150

2.3.2. More Operators¶ 2.3.2. 更多运算符 ¶

We’ve covered most of the built-in operators above, but there are a few more that you can see in the OCaml manual.
我们已经介绍了上面的大部分内置运算符，但您还可以在 OCaml 手册中看到更多内容。

There are two equality operators in OCaml, = and ==, with corresponding inequality operators <> and !=. Operators = and <> examine structural equality whereas == and != examine physical equality. Until we’ve studied the imperative features of OCaml, the difference between them will be tricky to explain. See the documentation of Stdlib.(==) if you’re curious now.
OCaml 中有两个相等运算符 = 和 == ，以及相应的不等运算符 <> 和 != 。运算符 = 和 <> 检查结构相等性，而 == 和 != 检查物理相等性。在我们研究 OCaml 的命令式功能之前，它们之间的差异很难解释。如果您现在好奇，请参阅 Stdlib.(==) 的文档。

2.3.3. Assertions¶ 2.3.3. 断言 ¶

The expression assert e evaluates e. If the result is true, nothing more happens, and the entire expression evaluates to a special value called unit. The unit value is written () and its type is unit. But if the result is false, an exception is raised.
表达式 assert e 计算 e 。如果结果是 true ，则不会再发生任何事情，并且整个表达式的计算结果为一个称为单位的特殊值。单位值写作 () ，其类型为 unit 。但如果结果是 false ，则会引发异常。

2.3.4. If Expressions¶ 2.3.4. If 表达式 ¶

The expression if e1 then e2 else e3 evaluates to e2 if e1 evaluates to true, and to e3 otherwise. We call e1 the guard of the if expression.
如果 e1 计算结果为 true ，则表达式 if e1 then e2 else e3 计算结果为 e2 ，否则计算为 e3 。我们将 e1 称为 if 表达式的守卫。

if 3 + 5 > 2 then "yay!" else "boo!"

- : string = "yay!"

Unlike if-then-else statements that you may have used in imperative languages, if-then-else expressions in OCaml are just like any other expression; they can be put anywhere an expression can go. That makes them similar to the ternary operator ? : that you might have used in other languages.
与您在命令式语言中使用的 if-then-else 语句不同，OCaml 中的 if-then-else 表达式就像任何其他表达式一样；它们可以放在表达式可以到达的任何地方。这使得它们类似于您可能在其他语言中使用的三元运算符 ? : 。

4 + (if 'a' = 'b' then 1 else 2)

- : int = 6

If expressions can be nested in a pleasant way:
If 表达式可以以一种愉快的方式嵌套：

if e1 then e2
else if e3 then e4
else if e5 then e6
...
else en

You should regard the final else as mandatory, regardless of whether you are writing a single if expression or a highly nested if expression. If you omit it you’ll likely get an error message that, for now, is inscrutable:
无论您是编写单个 if 表达式还是高度嵌套的 if 表达式，您都应该将最终的 else 视为强制性的。如果省略它，您可能会收到一条目前难以理解的错误消息：

if 2 > 3 then 5

File "[20]", line 1, characters 14-15:
1 | if 2 > 3 then 5
                  ^
Error: This expression has type int but an expression was expected of type
         unit
       because it is in the result of a conditional with no else branch

Syntax. The syntax of an if expression:
句法。 if 表达式的语法：

if e1 then e2 else e3

The letter e is used here to represent any other OCaml expression; it’s an example of a syntactic variable aka metavariable, which is not actually a variable in the OCaml language itself, but instead a name for a certain syntactic construct. The numbers after the letter e are being used to distinguish the three different occurrences of it.
此处使用字母 e 来表示任何其他 OCaml 表达式；这是一个语法变量（也称为元变量）的示例，它实际上并不是 OCaml 语言本身的变量，而是某个语法结构的名称。字母 e 后面的数字用于区分它的三个不同出现。

Dynamic semantics. The dynamic semantics of an if expression:
动态语义。 if 表达式的动态语义：

• If e1 evaluates to true, and if e2 evaluates to a value v, then if e1 then e2 else e3 evaluates to v
  如果 e1 计算结果为 true ，并且 e2 计算结果为值 v ，则 if e1 then e2 else e3 计算结果为 v 。

• If e1 evaluates to false, and if e3 evaluates to a value v, then if e1 then e2 else e3 evaluates to v.
  如果 e1 计算结果为 false ，并且 e3 计算结果为值 v ，则 if e1 then e2 else e3 计算结果为 v 。

We call these evaluation rules: they define how to evaluate expressions. Note how it takes two rules to describe the evaluation of an if expression, one for when the guard is true, and one for when the guard is false. The letter v is used here to represent any OCaml value; it’s another example of a metavariable. Later we will develop a more mathematical way of expressing dynamic semantics, but for now we’ll stick with this more informal style of explanation.
我们称这些评估规则为：它们定义如何评估表达式。请注意，如何使用两条规则来描述 if 表达式的求值，一条用于当防护为 true 时，另一条用于当防护为 false 时。此处使用字母 v 来表示任何 OCaml 值；这是元变量的另一个例子。稍后我们将开发一种更数学的方式来表达动态语义，但现在我们将坚持这种更非正式的解释风格。

Static semantics. The static semantics of an if expression:
静态语义。 if 表达式的静态语义：

• If e1 has type bool and e2 has type t and e3 has type t then if e1 then e2 else e3 has type t
  如果 e1 具有类型 bool 且 e2 具有类型 t 且 e3 具有类型 t 那么 if e1 then e2 else e3 的类型为 t

We call this a typing rule: it describes how to type check an expression. Note how it only takes one rule to describe the type checking of an if expression. At compile time, when type checking is done, it makes no difference whether the guard is true or false; in fact, there’s no way for the compiler to know what value the guard will have at run time. The letter t here is used to represent any OCaml type; the OCaml manual also has definition of all types (which curiously does not name the base types of the language like int and bool).
我们称其为键入规则：它描述了如何键入检查表达式。请注意，如何只需要一条规则来描述 if 表达式的类型检查。在编译时，当进行类型检查时，守卫是 true 或 false 都没有区别；事实上，编译器无法知道守卫在运行时将具有什么值。这里的字母 t 用于表示任何OCaml类型； OCaml 手册还定义了所有类型（奇怪的是，它没有命名语言的基本类型，如 int 和 bool ）。

We’re going to be writing “has type” a lot, so let’s introduce a more compact notation for it. Whenever we would write “e has type t”, let’s instead write e : t. The colon is pronounced “has type”. This usage of colon is consistent with how the toplevel responds after it evaluates an expression that you enter:
我们将经常写“has type”，所以让我们为它引入一个更紧凑的表示法。每当我们写“ e has type t ”时，我们就写 e : t 。冒号发音为“has type”。冒号的这种用法与顶层在计算您输入的表达式后的响应方式一致：

let x = 42

val x : int = 42

In the above example, variable x has type int, which is what the colon indicates.
在上面的示例中，变量 x 的类型为 int ，这就是冒号所指示的类型。

2.3.5. Let Expressions¶ 2.3.5. Let 表达式 ¶

In our use of the word let thus far, we’ve been making definitions in the toplevel and in .ml files. For example,
到目前为止，在我们使用单词 let 时，我们一直在顶层和 .ml 文件中进行定义。例如，

let x = 42;;

val x : int = 42

defines x to be 42, after which we can use x in future definitions at the toplevel. We’ll call this use of let a let definition.
将 x 定义为 42，之后我们可以在将来的顶层定义中使用 x 。我们将 let 的这种使用称为 let 定义。

There’s another use of let which is as an expression:
let 还有另一种用法，即作为表达式：

let x = 42 in x + 1

- : int = 43

Here we’re binding a value to the name x then using that binding inside another expression, x+1. We’ll call this use of let a let expression. Since it’s an expression it evaluates to a value. That’s different than definitions, which themselves do not evaluate to any value. You can see that if you try putting a let definition in place of where an expression is expected:
在这里，我们将一个值绑定到名称 x ，然后在另一个表达式 x+1 中使用该绑定。我们将 let 的这种用法称为 let 表达式。因为它是一个表达式，所以它的计算结果是一个值。这与定义不同，定义本身不会评估任何值。您可以看到，如果尝试将 let 定义放在需要表达式的位置：

(let x = 42) + 1

File "[24]", line 1, characters 11-12:
1 | (let x = 42) + 1
               ^
Error: Syntax error

Syntactically, a let definition is not permitted on the left-hand side of the + operator, because a value is needed there, and definitions do not evaluate to values. On the other hand, a let expression would work fine:
从语法上讲， let 定义不允许出现在 + 运算符的左侧，因为那里需要一个值，并且定义不会计算为值。另一方面， let 表达式可以正常工作：

(let x = 42 in x) + 1

- : int = 43

Another way to understand let definitions at the toplevel is that they are like let expression where we just haven’t provided the body expression yet. Implicitly, that body expression is whatever else we type in the future. For example,
理解顶层的 let 定义的另一种方法是，它们就像 let 表达式，只是我们还没有提供主体表达式。隐含地，该身​​体表情就是我们将来键入的任何其他内容。例如，

# let a = "big";;
# let b = "red";;
# let c = a ^ b;;
# ...

is understand by OCaml in the same way as
OCaml 的理解方式与

let a = "big" in
let b = "red" in
let c = a ^ b in
...

That latter series of let bindings is idiomatically how several variables can be bound inside a given block of code.
后一系列 let 绑定是惯用的方式，可以将多个变量绑定到给定的代码块内。

Syntax.

let x = e1 in e2

As usual, x is an identifier. These identifiers must begin with lower-case, not upper, and idiomatically are written with snake_case not camelCase. We call e1 the binding expression, because it’s what’s being bound to x; and we call e2 the body expression, because that’s the body of code in which the binding will be in scope.
与往常一样， x 是一个标识符。这些标识符必须以小写字母开头，而不是大写字母，并且通常用 snake_case 而不是 camelCase 编写。我们将 e1 称为绑定表达式，因为它是绑定到 x 的内容；我们将 e2 称为主体表达式，因为这是绑定范围内的代码主体。

Dynamic semantics. 动态语义。

To evaluate let x = e1 in e2: 评估 let x = e1 in e2 ：

• Evaluate e1 to a value v1.
  将 e1 计算为值 v1 。

• Substitute v1 for x in e2, yielding a new expression e2'.
  将 e2 中的 x 替换为 v1 ，产生新的表达式 e2' 。

• Evaluate e2' to a value v2.
  将 e2' 计算为值 v2 。

• The result of evaluating the let expression is v2.
  let 表达式的计算结果是 v2 。

Here’s an example: 这是一个例子：

    let x = 1 + 4 in x * 3
-->   (evaluate e1 to a value v1)
    let x = 5 in x * 3
-->   (substitute v1 for x in e2, yielding e2')
    5 * 3
-->   (evaluate e2' to v2)
    15
      (result of evaluation is v2)

Static semantics. 静态语义。

• If e1 : t1 and if under the assumption that x : t1 it holds that e2 : t2, then (let x = e1 in e2) : t2.
  如果 e1 : t1 并且在假设 x : t1 的情况下它保持 e2 : t2 ，则 (let x = e1 in e2) : t2 。

We use the parentheses above just for clarity. As usual, the compiler’s type inferencer determines what the type of the variable is, or the programmer could explicitly annotate it with this syntax:
我们使用上面的括号只是为了清楚起见。像往常一样，编译器的类型推断器确定变量的类型，或者程序员可以使用以下语法显式注释它：

let x : t = e1 in e2

2.3.6. Scope¶ 2.3.6. 范围 ¶

Let bindings are in effect only in the block of code in which they occur. This is exactly what you’re used to from nearly any modern programming language. For example:
Let 绑定仅在它们出现的代码块中有效。这正是您在几乎所有现代编程语言中所习惯的。例如：

let x = 42 in
  (* y is not meaningful here *)
  x + (let y = "3110" in
         (* y is meaningful here *)
         int_of_string y)

The scope of a variable is where its name is meaningful. Variable y is in scope only inside of the let expression that binds it above.
变量的作用域是其名称有意义的地方。变量 y 的作用域仅位于上面绑定它的 let 表达式内部。

It’s possible to have overlapping bindings of the same name. For example:
可能存在同名的重叠绑定。例如：

let x = 5 in
  ((let x = 6 in x) + x)

But this is darn confusing, and for that reason, it is strongly discouraged style—much like ambiguous pronouns are discouraged in natural language. Nonetheless, let’s consider what that code means.
但这实在令人困惑，因此，这是一种强烈不鼓励的风格——就像自然语言中不鼓励使用歧义代词一样。尽管如此，让我们考虑一下该代码的含义。

To what value does that code evaluate? The answer comes down to how x is replaced by a value each time it occurs. Here are a few possibilities for such substitution:
该代码计算出什么值？答案归结为 x 每次出现时如何被一个值替换。以下是这种替代的几种可能性：

(* possibility 1 *)
let x = 5 in
  ((let x = 6 in 6) + 5)

(* possibility 2 *)
let x = 5 in
  ((let x = 6 in 5) + 5)

(* possibility 3 *)
let x = 5 in
  ((let x = 6 in 6) + 6)

The first one is what nearly any reasonable language would do. And most likely it’s what you would guess But, why?
第一个是几乎任何合理的语言都会做的事情。最有可能的是你会猜到但是，为什么呢？

The answer is something we’ll call the Principle of Name Irrelevance: the name of a variable shouldn’t intrinsically matter. You’re used to this from math. For example, the following two functions are the same:
答案就是我们所说的名称无关原则：变量的名称本质上不应该重要。你在数学上已经习惯了这一点。例如，以下两个函数是相同的：

It doesn’t intrinsically matter whether we call the argument to the function x$x$ or y$y$; either way, it’s still the squaring function. Therefore, in programs, these two functions should be identical:
我们是否调用函数的参数 x$x$ 还是 y$y$ 本质上并不重要；不管怎样，它仍然是平方函数。因此，在程序中，这两个函数应该是相同的：

let f x = x * x
let f y = y * y

This principle is more commonly known as alpha equivalence: the two functions are equivalent up to renaming of variables, which is also called alpha conversion for historical reasons that are unimportant here.
这一原则通常被称为 alpha 等价：两个函数在变量重命名之前是等价的，由于历史原因（这里不重要），这也称为 alpha 转换。

According to the Principle of Name Irrelevance, these two expressions should be identical:
根据名称无关原则，这两个表达式应该是相同的：

let x = 6 in x
let y = 6 in y

Therefore, the following two expressions, which have the above expressions embedded in them, should also be identical:
因此，嵌入了上述表达式的以下两个表达式也应该是相同的：

let x = 5 in (let x = 6 in x) + x
let x = 5 in (let y = 6 in y) + x

But for those to be identical, we must choose the first of the three possibilities above. It is the only one that makes the name of the variable be irrelevant.
但为了使它们相同，我们必须选择上述三种可能性中的第一种。这是唯一一个使变量名称变得无关紧要的。

There is a term commonly used for this phenomenon: a new binding of a variable shadows any old binding of the variable name. Metaphorically, it’s as if the new binding temporarily casts a shadow over the old binding. But eventually the old binding could reappear as the shadow recedes.
有一个术语通常用于描述这种现象：变量的新绑定会隐藏变量名称的任何旧绑定。打个比方，就好像新绑定暂时在旧绑定上投下了阴影。但最终，随着阴影消退，旧的绑定可能会重新出现。

Shadowing is not mutable assignment.
阴影不是可变分配。 For example, both of the following expressions evaluate to 11:

let x = 5 in ((let x = 6 in x) + x)
let x = 5 in (x + (let x = 6 in x))

Likewise, the following utop transcript is not mutable assignment, though at first it could seem like it is:
同样，以下 utop 转录本不是可变赋值，尽管乍一看似乎是这样：

# let x = 42;;
val x : int = 42
# let x = 22;;
val x : int = 22

Recall that every let definition in the toplevel is effectively a nested let expression. So the above is effectively the following:
回想一下，顶层中的每个 let 定义实际上都是一个嵌套的 let 表达式。所以上面的内容实际上如下：

let x = 42 in
  let x = 22 in
    ... (* whatever else is typed in the toplevel *)

The right way to think about this is that the second let binds an entirely new variable that just happens to have the same name as the first let.
正确的思考方式是，第二个 let 绑定一个全新的变量，该变量恰好与第一个 let 具有相同的名称。

Here is another utop transcript that is well worth studying:
这是另一个非常值得研究的 utop 成绩单：

# let x = 42;;
val x : int = 42
# let f y = x + y;;
val f : int -> int = <fun>
# f 0;;
: int = 42
# let x = 22;;
val x : int = 22
# f 0;;
- : int = 42  (* x did not mutate! *)

To summarize, each let definition binds an entirely new variable. If that new variable happens to have the same name as an old variable, the new variable temporarily shadows the old one. But the old variable is still around, and its value is immutable: it never, ever changes. So even though let expressions might superficially look like assignment statements from imperative languages, they are actually quite different.
总而言之，每个 let 定义都绑定一个全新的变量。如果新变量碰巧与旧变量同名，则新变量会暂时隐藏旧变量。但旧变量仍然存在，并且它的值是不可变的：它永远不会改变。因此，尽管 let 表达式表面上看起来像命令式语言中的赋值语句，但它们实际上是完全不同的。

2.3.7. Type Annotations¶
2.3.7. 类型注释 ¶

OCaml automatically infers the type of every expression, with no need for the programmer to write it manually. Nonetheless, it can sometimes be useful to manually specify the desired type of an expression. A type annotation does that:
OCaml 自动推断每个表达式的类型，无需程序员手动编写。尽管如此，有时手动指定所需的表达式类型还是很有用的。类型注释的作用是：

(5 : int)

- : int = 5

An incorrect annotation will produce a compile-time error:
不正确的注释将产生编译时错误：

(5 : float)

File "[27]", line 1, characters 1-2:
1 | (5 : float)
     ^
Error: This expression has type int but an expression was expected of type
         float
  Hint: Did you mean `5.'?

And that example shows why you might use manual type annotations during debugging. Perhaps you had forgotten that 5 cannot be treated as a float, and you tried to write:
该示例说明了为什么您可以在调试期间使用手动类型注释。也许您忘记了 5 不能被视为 float ，并且您尝试编写：

5 +. 1.1

You might try manually specifying that 5 was supposed to be a float:
您可以尝试手动指定 5 应该是 float ：

(5 : float) +. 1.1

File "[28]", line 1, characters 1-2:
1 | (5 : float) +. 1.1
     ^
Error: This expression has type int but an expression was expected of type
         float
  Hint: Did you mean `5.'?

It’s clear that the type annotation has failed. Although that might seem silly for this tiny program, you might find this technique to be effective as programs get larger.
很明显，类型注释失败了。尽管这对于这个小程序来说可能看起来很愚蠢，但随着程序变得越来越大，您可能会发现这种技术很有效。

Syntax. The syntax of a type annotation:
句法。类型注释的语法：

(e : t)

Note that the parentheses are required.
请注意，括号是必需的。

Dynamic semantics. There is no run-time meaning for a type annotation. It goes away during compilation, because it indicates a compile-time check. There is no run-time conversion. So, if (e : t) compiled successfully, then at run-time it is simply e, and it evaluates as e would.
动态语义。类型注释没有运行时意义。它在编译期间消失，因为它指示编译时检查。没有运行时转换。因此，如果 (e : t) 编译成功，那么在运行时它只是 e ，并且其计算结果与 e 相同。

Static semantics. If e has type t then (e : t) has type t.
静态语义。如果 e 具有类型 t ，则 (e : t) 具有类型 t 。

2.4.1. Function Definitions¶
2.4.1. 函数定义 ¶

The following code 下面的代码

let x = 42

has an expression in it (42) but is not itself an expression. Rather, it is a definition. Definitions bind values to names, in this case the value 42 being bound to the name x. The OCaml manual describes definitions (see the third major grouping titled “definition” on that page), but that manual page is again primarily for reference not for study. Definitions are not expressions, nor are expressions definitions—they are distinct syntactic classes.
其中有一个表达式 ( 42 )，但它本身不是一个表达式。相反，它是一个定义。定义将值绑定到名称，在本例中，值 42 绑定到名称 x 。 OCaml 手册描述了定义（请参阅该页面上标题为“定义”的第三个主要分组），但该手册页同样主要用于参考而不是用于研究。定义不是表达式，表达式定义也不是——它们是不同的语法类。

For now, let’s focus on one particular kind of definition, a function definition. Non-recursive functions are defined like this:
现在，让我们关注一种特定类型的定义，即函数定义。非递归函数的定义如下：

let f x = ...

Recursive functions are defined like this:
递归函数的定义如下：

let rec f x = ...

The difference is just the rec keyword. It’s probably a bit surprising that you explicitly have to add a keyword to make a function recursive, because most languages assume by default that they are. OCaml doesn’t make that assumption, though. (Nor does the Scheme family of languages.)
区别只是 rec 关键字。明确必须添加关键字才能使函数递归可能有点令人惊讶，因为大多数语言默认情况下都假设它们是递归的。但 OCaml 并没有做出这样的假设。 （Scheme 语言家族也没有。）

One of the best known recursive functions is the factorial function. In OCaml, it can be written as follows:
最著名的递归函数之一是阶乘函数。在OCaml中，可以写成如下：

(** [fact n] is [n]!.
    Requires: [n >= 0]. *)
let rec fact n = if n = 0 then 1 else n * fact (n - 1)

val fact : int -> int = <fun>

We provided a specification comment above the function to document the precondition (Requires) and postcondition (is) of the function.
我们在函数上方提供了规范注释来记录函数的前置条件 ( Requires ) 和后置条件 ( is )。

Note that, as in many languages, OCaml integers are not the “mathematical” integers but are limited to a fixed number of bits. The manual specifies that (signed) integers are at least 31 bits, but they could be wider. As architectures have grown, so has that size. In current implementations, OCaml integers are 63 bits. So if you test on large enough inputs, you might begin to see strange results. The problem is machine arithmetic, not OCaml. (For interested readers: why 31 or 63 instead of 32 or 64? The OCaml garbage collector needs to distinguish between integers and pointers. The runtime representation of these therefore steals one bit to flag whether a word is an integer or a pointer.)
请注意，与许多语言一样，OCaml 整数不是“数学”整数，而是限制为固定位数。手册规定（有符号）整数至少为 31 位，但它们可以更宽。随着架构的发展，其规模也随之扩大。在当前的实现中，OCaml 整数是 63 位。因此，如果您在足够大的输入上进行测试，您可能会开始看到奇怪的结果。问题是机器算术，而不是 OCaml。 （感兴趣的读者：为什么是 31 或 63，而不是 32 或 64？OCaml 垃圾收集器需要区分整数和指针。因此，它们的运行时表示会窃取一位来标记一个字是整数还是指针。）

Here’s another recursive function:
这是另一个递归函数：

(** [pow x y] is [x] to the power of [y].
     Requires: [y >= 0]. *)
let rec pow x y = if y = 0 then 1 else x * pow x (y - 1)

val pow : int -> int -> int = <fun>

Note how we didn’t have to write any types in either of our functions: the OCaml compiler infers them for us automatically. The compiler solves this type inference problem algorithmically, but we could do it ourselves, too. It’s like a mystery that can be solved by our mental power of deduction:
请注意，我们不必在任何一个函数中编写任何类型：OCaml 编译器会自动为我们推断它们。编译器通过算法解决了这种类型推断问题，但我们也可以自己做。这就像一个谜团，可以通过我们的精神力推演来解开：

• Since the if expression can return 1 in the then branch, we know by the typing rule for if that the entire if expression has type int.
  由于 if 表达式可以在 then 分支中返回 1 ，因此通过 if 的键入规则我们知道整个 if 表达式的类型为 int 。

• Since the if expression has type int, the function’s return type must be int.
  由于 if 表达式的类型为 int ，因此函数的返回类型必须为 int 。

• Since y is compared to 0 with the equality operator, y must be an int.
  由于 y 与 0 使用相等运算符进行比较，因此 y 必须是 int 。

• Since x is multiplied with another expression using the * operator, x must be an int.
  由于 x 使用 * 运算符与另一个表达式相乘，因此 x 必须是 int 。

If we wanted to write down the types for some reason, we could do that:
如果我们出于某种原因想写下类型，我们可以这样做：

let rec pow (x : int) (y : int) : int = ...

The parentheses are mandatory when we write the type annotations for x and y. We will generally leave out these annotations, because it’s simpler to let the compiler infer them. There are other times when you’ll want to explicitly write down types. One particularly useful time is when you get a type error from the compiler that you don’t understand. Explicitly annotating the types can help with debugging such an error message.
当我们为 x 和 y 编写类型注释时，括号是必需的。我们通常会省略这些注释，因为让编译器推断它们更简单。有时您会想要显式地写下类型。一个特别有用的时刻是当您从编译器中收到您不理解的类型错误时。显式注释类型可以帮助调试此类错误消息。

Syntax. The syntax for function definitions:
句法。函数定义的语法：

let rec f x1 x2 ... xn = e

The f is a metavariable indicating an identifier being used as a function name. These identifiers must begin with a lowercase letter. The remaining rules for lowercase identifiers can be found in the manual. The names x1 through xn are metavariables indicating argument identifiers. These follow the same rules as function identifiers. The keyword rec is required if f is to be a recursive function; otherwise it may be omitted.
f 是指示用作函数名称的标识符的元变量。这些标识符必须以小写字母开头。小写标识符的其余规则可以在手册中找到。名称 x1 到 xn 是指示参数标识符的元变量。它们遵循与函数标识符相同的规则。如果 f 是递归函数，则需要关键字 rec ；否则可以省略。

Note that syntax for function definitions is actually simplified compared to what OCaml really allows. We will learn more about some augmented syntax for function definition in the next couple weeks. But for now, this simplified version will help us focus.
请注意，与 OCaml 真正允许的语法相比，函数定义的语法实际上得到了简化。在接下来的几周内，我们将详细了解函数定义的一些增强语法。但就目前而言，这个简化版本将帮助我们集中注意力。

Mutually recursive functions can be defined with the and keyword:
可以使用 and 关键字定义相互递归函数：

let rec f x1 ... xn = e1
and g y1 ... yn = e2

For example: 例如：

(** [even n] is whether [n] is even.
    Requires: [n >= 0]. *)
let rec even n =
  n = 0 || odd (n - 1)

(** [odd n] is whether [n] is odd.
    Requires: [n >= 0]. *)
and odd n =
  n <> 0 && even (n - 1);;

val even : int -> bool = <fun>
val odd : int -> bool = <fun>

The syntax for function types is:
函数类型的语法是：

t -> u
t1 -> t2 -> u
t1 -> ... -> tn -> u

The t and u are metavariables indicating types. Type t -> u is the type of a function that takes an input of type t and returns an output of type u. We can think of t1 -> t2 -> u as the type of a function that takes two inputs, the first of type t1 and the second of type t2, and returns an output of type u. Likewise for a function that takes n arguments.
t 和 u 是指示类型的元变量。类型 t -> u 是接受 t 类型输入并返回 u 类型输出的函数类型。我们可以将 t1 -> t2 -> u 视为接受两个输入的函数类型，第一个输入为 t1 类型，第二个输入为 t2 类型，并返回输出类型为 u 。对于采用 n 参数的函数也是如此。

Dynamic semantics. There is no dynamic semantics of function definitions. There is nothing to be evaluated. OCaml just records that the name f is bound to a function with the given arguments x1..xn and the given body e. Only later, when the function is applied, will there be some evaluation to do.
动态语义。函数定义没有动态语义。没有什么可以评价的。 OCaml 仅记录名称 f 绑定到具有给定参数 x1..xn 和给定主体 e 的函数。只有稍后应用该功能时，才会进行一些评估。

Static semantics. The static semantics of function definitions:
静态语义。函数定义的静态语义：

• For non-recursive functions: if by assuming that x1 : t1 and x2 : t2 and … and xn : tn, we can conclude that e : u, then f : t1 -> t2 -> ... -> tn -> u.
  对于非递归函数：如果通过假设 x1 : t1 和 x2 : t2 以及 ... 和 xn : tn ，我们可以得出 e : u 的结论，那么 f : t1 -> t2 -> ... -> tn -> u 。

• For recursive functions: if by assuming that x1 : t1 and x2 : t2 and … and xn : tn and f : t1 -> t2 -> ... -> tn -> u, we can conclude that e : u, then f : t1 -> t2 -> ... -> tn -> u.
  对于递归函数：如果通过假设 x1 : t1 和 x2 : t2 和 ... 以及 xn : tn 和 f : t1 -> t2 -> ... -> tn -> u ，我们可以得出 e : u 。

Note how the type checking rule for recursive functions assumes that the function identifier f has a particular type, then checks to see whether the body of the function is well-typed under that assumption. This is because f is in scope inside the function body itself (just like the arguments are in scope).
请注意递归函数的类型检查规则如何假设函数标识符 f 具有特定类型，然后检查函数体在该假设下是否类型正确。这是因为 f 位于函数体本身的范围内（就像参数位于范围内一样）。

2.4.2. Anonymous Functions¶
2.4.2. 匿名函数 ¶

We already know that we can have values that are not bound to names. The integer 42, for example, can be entered at the toplevel without giving it a name:
我们已经知道我们可以拥有不与名称绑定的值。例如，可以在顶层输入整数 42 而无需为其指定名称：

42

- : int = 42

Or we can bind it to a name:
或者我们可以将它绑定到一个名称：

let x = 42